package com.app.video;

import android.app.Activity;
import android.content.Context;
import android.hardware.Camera;
import android.hardware.Camera.Size;
import android.util.Log;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;

import com.app.MyCamera;
import com.app.util.Utils_Log;

import java.io.IOException;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;

/**
 * Created by matengfei on 15/8/2.
 */
public class MyVideoCameraPreview implements Camera.AutoFocusCallback {


    MyVideoCameraPreview myvideocamerapreview = this;

    private final String TAG = MyVideoCameraPreview.class.getSimpleName();
    private Preview mPreview;
    public MyCamera mycamera = new MyCamera();
    int numberOfCameras;
    int cameraCurrentlyLocked;

    // The first rear facing camera
    int defaultCameraId;

    Activity activity;


    //MultiFormatReader multiFormatReader;


    // 设置定时器，设置自动对焦监听，点击预览屏幕显示矩形框体；
    Timer timer = new Timer();


    public View init(Activity activity){
        this.activity = activity;

        // Create a RelativeLayout container that will hold a SurfaceView,
        // and set it as the content of our activity.
        mPreview = new Preview(activity);


        return mPreview;
    }


    void init_zxing(){
        //Map<DecodeHintType,Object> hints = new HashMap<>();
        //Collection<BarcodeFormat> decodeFormats = new ArrayList<>();
        //decodeFormats.add( BarcodeFormat.QR_CODE );
        //hints.put(DecodeHintType.POSSIBLE_FORMATS, decodeFormats);

        /*
        Hashtable<DecodeHintType, Object> hints = new Hashtable<>();
        Vector<BarcodeFormat> vec = new Vector<>();
        vec.add( BarcodeFormat.QR_CODE );
        hints.put(DecodeHintType.POSSIBLE_FORMATS, vec);
        multiFormatReader = new MultiFormatReader();
        multiFormatReader.setHints(hints);
        */

        //PlanarYUVLuminanceSource source = new PlanarYUVLuminanceSource(data, width, height, rect.left, rect.top,
        //        rect.width(), rect.height(), false);



    }


    public void start(){
        // Open the default i.e. the first rear facing camera.
        mycamera.open();
        mPreview.setCamera();


        mycamera.printSupportFocusMode();
        mycamera.printSupportPictureSize();
        mycamera.printSupportPreviewSize();


        // camera设置焦点，自动对焦, 会执行一次, 会使屏幕显示清晰
        mycamera.mCamera.autoFocus(new Camera.AutoFocusCallback() {
            @Override
            public void onAutoFocus(boolean success, Camera camera) {

            }
        });

        // 设置预览回调
        mycamera.mCamera.setPreviewCallback(new Camera.PreviewCallback() {
            @Override
            public void onPreviewFrame(byte[] data, Camera camera) {

                Log.i(TAG, ""+data.length);



            }
        });


        // 开启定时任务
        timer.schedule( new MyTimerTask(), 5000, 5000);


    }

    public void close(){
        // Because the Camera object is a shared resource, it's very
        // important to release it when the activity is paused.

        // 关闭定时器
        if(timer != null){
            timer.cancel();
            timer = null;
        }

        /* 放在surface，destory中管理了；
        if (mycamera.mCamera != null) {
            //mPreview.setCamera(null);
            mycamera.close();
        }
        */


    }

    public void Switch(){


        mycamera.Switch();
        mPreview.switchCamera();

        // Start the preview
        mycamera.mCamera.startPreview();

    }


    public void SetAutoFoucs( ){

        // camera设置焦点，自动对焦, 会执行一次, 会使屏幕显示清晰
        mycamera.mCamera.autoFocus( this );

    }

    @Override
    public void onAutoFocus(boolean success, Camera camera) {

    }


    class MyTimerTask extends TimerTask {

        @Override
        public void run() {

            //mycamera.mCamera.autoFocus( myvideocamerapreview );


        }
    }


    public void zoom(){


        //mycamera.mCamera.getParameters().setZoom();


    }

// ----------------------------------------------------------------------

    /**
     * A simple wrapper around a Camera and a SurfaceView that renders a centered preview of the Camera
     * to the surface. We need to center the SurfaceView because not all devices have cameras that
     * support preview sizes at the same aspect ratio as the device's display.
     */
    class Preview extends ViewGroup implements SurfaceHolder.Callback {
        private final String TAG = "Preview";

        SurfaceView mSurfaceView;
        SurfaceHolder mHolder;
        Size mPreviewSize;
        List<Size> mSupportedPreviewSizes;
        //Camera mCamera;

        Preview(Context context) {
            super(context);

            mSurfaceView = new SurfaceView(context);
            addView(mSurfaceView);

            // Install a SurfaceHolder.Callback so we get notified when the
            // underlying surface is created and destroyed.
            mHolder = mSurfaceView.getHolder();
            mHolder.addCallback(this);
            mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        }

        public void setCamera( ) {
            if (mycamera.mCamera != null) {
                mSupportedPreviewSizes = mycamera.mCamera.getParameters().getSupportedPreviewSizes();
                requestLayout();
            }
        }

        public void switchCamera( ) {
            try {
                mycamera.mCamera.setPreviewDisplay(mHolder);
            } catch (IOException exception) {
                Log.e(TAG, "IOException caused by setPreviewDisplay()", exception);
            }
            Camera.Parameters parameters = mycamera.mCamera.getParameters();
            parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
            requestLayout();

            mycamera.mCamera.setParameters(parameters);
        }

        @Override
        protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
            // We purposely disregard child measurements because act as a
            // wrapper to a SurfaceView that centers the camera preview instead
            // of stretching it.
            final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
            final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
            setMeasuredDimension(width, height);

            if (mSupportedPreviewSizes != null) {
                mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
            }
        }

        @Override
        protected void onLayout(boolean changed, int l, int t, int r, int b) {
            if (changed && getChildCount() > 0) {
                final View child = getChildAt(0);

                final int width = r - l;
                final int height = b - t;

                int previewWidth = width;
                int previewHeight = height;
                if (mPreviewSize != null) {
                    previewWidth = mPreviewSize.width;
                    previewHeight = mPreviewSize.height;
                }

                child.layout(l, t, r, b);

                /* 使
                // Center the child SurfaceView within the parent.
                if (width * previewHeight > height * previewWidth) {
                    final int scaledChildWidth = previewWidth * height / previewHeight;
                    child.layout((width - scaledChildWidth) / 2, 0,
                            (width + scaledChildWidth) / 2, height);
                } else {
                    final int scaledChildHeight = previewHeight * width / previewWidth;
                    child.layout(0, (height - scaledChildHeight) / 2,
                            width, (height + scaledChildHeight) / 2);
                }
                */

            }
        }

        public void surfaceCreated(SurfaceHolder holder) {
            // The Surface has been created, acquire the camera and tell it where
            // to draw.
            try {
                if (mycamera.mCamera != null) {
                    mycamera.mCamera.setPreviewDisplay(holder);
                }
            } catch (IOException exception) {
                Log.e(TAG, "IOException caused by setPreviewDisplay()", exception);
            }
        }

        public void surfaceDestroyed(SurfaceHolder holder) {
            // Surface will be destroyed when we return, so stop the preview.
            if (mycamera.mCamera != null) {
                mycamera.mCamera.setPreviewCallback(null) ;
                mycamera.close();
            }


        }


        private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) {
            final double ASPECT_TOLERANCE = 0.1;
            double targetRatio = (double) w / h;
            if (sizes == null) return null;

            Size optimalSize = null;
            double minDiff = Double.MAX_VALUE;

            int targetHeight = h;

            // Try to find an size match aspect ratio and size
            for (Size size : sizes) {
                double ratio = (double) size.width / size.height;
                if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
                if (Math.abs(size.height - targetHeight) < minDiff) {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight);
                }
            }

            // Cannot find the one match the aspect ratio, ignore the requirement
            if (optimalSize == null) {
                minDiff = Double.MAX_VALUE;
                for (Size size : sizes) {
                    if (Math.abs(size.height - targetHeight) < minDiff) {
                        optimalSize = size;
                        minDiff = Math.abs(size.height - targetHeight);
                    }
                }
            }
            return optimalSize;
        }

        public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
            // Now that the size is known, set up the camera parameters and begin
            // the preview.
           // mycamera.surfaceChanged(holder, format, w, h);
           // mycamera.mCamera.startPreview();


            // 调整
            MyCamera.setCameraDisplayOrientation(activity, mycamera.mCameraCurrentlyLocked, mycamera.mCamera);


            //mCamera.setDisplayOrientation(90);
            Camera.Parameters parameters = mycamera.mCamera.getParameters();
            parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
            requestLayout();

            Utils_Log.e(TAG, "preview_width: "+mPreviewSize.width + " preview_height: "+mPreviewSize.height);



            mycamera.mCamera.setParameters(parameters);
            mycamera.mCamera.startPreview();
        }


    }


}
